home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Source Code / Visual Basic Source Code.iso / vbsource / vbdatabs / ustring.h < prev    next >
Encoding:
C/C++ Source or Header  |  1999-03-31  |  10.4 KB  |  279 lines
  1. // ------------------------------- //
  2. // -------- Start of File -------- //
  3. // ------------------------------- //
  4. // ----------------------------------------------------------- //
  5. // C++ Header File Name: ustring.h 
  6. // Compiler Used: MSVC40, DJGPP 2.7.2.1, GCC 2.7.2.1, HP CPP 10.24
  7. // Produced By: Doug Gaer 
  8. // File Creation Date: 11/29/1996  
  9. // Date Last Modified: 03/31/1999
  10. // Copyright (c) 1997 Douglas M. Gaer
  11. // ----------------------------------------------------------- // 
  12. // ---------- Include File Description and Details  ---------- // 
  13. // ----------------------------------------------------------- // 
  14. /*
  15. The VBD C++ classes are copyright (c) 1997, by Douglas M. Gaer.
  16. All those who put this code or its derivatives in a commercial
  17. product MUST mention this copyright in their documentation for
  18. users of the products in which this code or its derivative
  19. classes are used. Otherwise, you have the freedom to redistribute
  20. verbatim copies of this source code, adapt it to your specific
  21. needs, or improve the code and release your improvements to the
  22. public provided that the modified files carry prominent notices
  23. stating that you changed the files and the date of any change.
  24.  
  25. THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND.
  26. THE ENTIRE RISK OF THE QUALITY AND PERFORMANCE OF THIS SOFTWARE
  27. IS WITH YOU. SHOULD ANY ELEMENT OF THIS SOFTWARE PROVE DEFECTIVE,
  28. YOU WILL ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR, OR
  29. CORRECTION.
  30.  
  31. The UString class is a user-defined string class used to create
  32. and manipulate non null-terminated resizable, variable-length
  33. strings of binary data. UString objects are implemented as a
  34. concrete data type, just like the built-in data types: char,
  35. int, long, float, and double. The UString class supports string
  36. concatenation, find, fill, and sub-string creation.
  37.  
  38. Changes:
  39. ================================================================
  40. 03/11/1999: - Added the IFind() string searching function to
  41. find matching patterns in strings without comparing the case.
  42. */
  43. // ----------------------------------------------------------- //   
  44. #ifndef __USTRING_HPP
  45. #define __USTRING_HPP
  46.  
  47. #include <iostream.h>
  48. #include <iomanip.h>
  49. #include <string.h>
  50.  
  51. // Set this macro DOS and Windows applications
  52. // #ifndef __DOS__
  53. // #define __DOS__
  54. // #endif 
  55.  
  56. // Set this macro Generic Unix applications
  57. // #ifndef __UNIX__
  58. // #define __UNIX__
  59. // #endif 
  60.  
  61. // (S)tring (D)ata class
  62. class StrData 
  63. {
  64. private:
  65.   friend class UString;
  66.   StrData() { RefCount = 1; }
  67.  
  68. private:
  69.   void *operator new(size_t StrSize, unsigned Bytes = 0);
  70.   void operator delete(void *ptr);
  71.   
  72. private:
  73.   unsigned int RefCount;   // Reference count for string text
  74.   char Data[1];            // Start of the string text
  75.   static StrData Null_Ptr; // For null strings
  76. };
  77.  
  78. // (U)ser-defined (S)tring class
  79. class UString
  80. {
  81. public:
  82.   enum { DefSize = 16, DefInc = 16, NoMatch = 0xffff };
  83.   UString(unsigned Bytes = DefSize, int GB = DefInc) { Alloc(Bytes, GB); }
  84.   UString(const char *s, int GB = DefInc);
  85.   UString(const char *s, unsigned Bytes, int GB = DefInc);
  86.   
  87.   // Constructor used to create substrings
  88.   UString(const UString &s,
  89.      unsigned Offset, unsigned Bytes, int GB = DefInc);
  90.  
  91.   ~UString();
  92.   UString(const UString &s);
  93.   UString &operator=(const UString &s);
  94.   UString &operator=(const char *s) { Copy(s); return *this; }
  95.   
  96. public:
  97.   // Append specified number of bytes from s onto end of this string
  98.   void Cat(const char *s, unsigned Bytes) { InsReplAt(Len, s, Bytes); }
  99.   void Cat(const char *s) { InsReplAt(Len, s, strlen(s)); }
  100.   void Copy(const char *s);    // Copy data from s into this object  
  101.   void Copy(const UString &s); // Copy data from s into this object
  102.  
  103.   // Return index of matching pattern or 0xffff if not found 
  104.   unsigned Find(char *s, unsigned Offset = 0); 
  105.   unsigned Find(char *s, unsigned Bytes, unsigned Offset = 0) const;
  106.   unsigned Find(const UString &s, unsigned Offset = 0) const {
  107.     return Find(s.TextPtr, s.Len, Offset); }
  108.   unsigned IFind(char *s, unsigned Offset = 0); 
  109.   unsigned IFind(char *s, unsigned Bytes, unsigned Offset = 0) const;
  110.   unsigned IFind(const UString &s, unsigned Offset = 0) const {
  111.     return IFind(s.TextPtr, s.Len, Offset); }
  112.   
  113.   // Deletes specifed number of bytes from starting position
  114.   unsigned DeleteAt(unsigned Pos, unsigned Bytes);
  115.  
  116.   // Replaces text at position Pos with bytes in s
  117.   unsigned ReplaceAt(unsigned Pos, const char *s, unsigned Bytes) {
  118.     return InsReplAt(Pos, s, Bytes, 0); }
  119.   unsigned ReplaceAt(unsigned Pos, const char *s) {
  120.     return InsReplAt(Pos, s, strlen(s), 0); }
  121.   unsigned ReplaceAt(unsigned Pos, const UString &s) {
  122.     return InsReplAt(Pos, s.TextPtr, s.Len, 0); }
  123.  
  124.   // Inserts text in s at position Pos
  125.   unsigned InsertAt(unsigned Pos, const char *s, unsigned Bytes) {
  126.     return InsReplAt(Pos, s, Bytes); }
  127.   unsigned InsertAt(unsigned Pos, const char *s) {
  128.     return InsReplAt(Pos, s, strlen(s)); }
  129.   unsigned InsertAt(unsigned Pos, const UString &s) {
  130.     return InsReplAt(Pos, s.TextPtr, s.Len); }
  131.   
  132.   // Fills the string with pattern p, up to length Ln, starting at Offset
  133.   void Fill(const char *p, unsigned Bytes, unsigned Offset=0, unsigned Ln=0);
  134.   void Fill(const char c, unsigned Offset=0, unsigned Ln=0) {
  135.     Fill(&c, 1, Offset, Ln); }
  136.   void Fill(const char *s, unsigned Offset=0, unsigned Ln=0) {
  137.     Fill(s, strlen(s), Offset, Ln); }
  138.   void Fill(const UString &s, unsigned Offset=0, unsigned Ln=0) {
  139.     Fill(s.TextPtr, s.Len, Offset, Ln); }
  140.  
  141.   // Returns substring starting at Index, for number of bytes
  142.   UString Mid(unsigned Index, unsigned Bytes) const; 
  143.  
  144.   UString Left(unsigned Ln) const;  // Returns left substring of length Ln
  145.   UString Right(unsigned Ln) const; // Returns right substring of length Ln
  146.  
  147.   // Make the string null-terminated
  148.   const char *UString::NullTermStr();
  149.  
  150.   unsigned GetLength() const { return Len; } // returns logical length
  151.   unsigned length() const { return Len; } // returns logical length
  152.   unsigned GetDimLen() const { return DimLen; } // returns allocated length
  153.   char *GetTextPtr() { return TextPtr; } // returns pointer to start of text
  154.   const char *GetTextPtr() const { return TextPtr; } 
  155.   char *c_str(); // returns NULL terminated low level C string 
  156.   const char *c_str() const;
  157.   int Grow() { return Realloc(DimLen + GrowBy); } // Grow by default amount
  158.   int Resize(unsigned Bytes) { return Realloc(Bytes); } // Resize the string
  159.   int resize(unsigned Bytes) { return Realloc(Bytes); } // Resize the string
  160.   int FreeExtra() { return Realloc(Len); } // Frees unused space in string
  161.   void ChgGrowByInc(int GB) { GrowBy = GB; } // Change GrowBy increment
  162.  
  163.   // Sets the logical length of the string to <= maximum length
  164.   void SetLength(unsigned Bytes);
  165.  
  166.   // Returns true if the string references Null_Ptr
  167.   int IsNull() const { return DataPtr == &StrData::Null_Ptr; }
  168.   int is_null() const { return DataPtr == &StrData::Null_Ptr; }
  169.   
  170. private: 
  171.   // Copies data from s, resizing if Bytes > DimLen && GrowBy != 0
  172.   void CopyN(const char *s, unsigned Bytes); 
  173.  
  174.   // Inserts/replaces data pointed by s, up to Bytes starting at Pos
  175.   unsigned InsReplAt(unsigned Pos, const char *s, unsigned Bytes, int Ins=1);
  176.  
  177.   // Grows the string by the specified amount
  178.   int Grow_By(unsigned Bytes) { return Realloc(DimLen + Bytes); }
  179.  
  180.   int EnsureUnique(); // Ensures that this string uniquely owns its data
  181.  
  182.   // Returns true if string references shared data or Null_Ptr
  183.   int IsUnique() const { return DataPtr->RefCount == 1 || IsNull(); }
  184.  
  185.   // Check for string index being in bounds
  186.   unsigned CheckIndex(unsigned i) {
  187.     if(i >= Len) i = Len; // If not in bounds truncate to Len
  188.     return i; }
  189.   
  190. private: // Memory allocation routines
  191.   // If memory allocation for new string fails reference a null string of 0
  192.   int Alloc(unsigned Bytes, int GB);
  193.  
  194.   // Redimenstions the string, returns 0 if memory not available
  195.   int Realloc(unsigned NewDimLen, int Keep = 1);
  196.  
  197.   // Binds to the same data that s is bound to
  198.   void Bind(const UString &s);
  199.   
  200.   void UnBind(); // Unbinds this object from the shared string data
  201.  
  202.   // Unbinds this string and then binds it to data shared by s
  203.   void NewBinding(const UString &s);
  204.  
  205. private: 
  206.   StrData *DataPtr;
  207.   char *TextPtr;   // Pointer to start of string text
  208.   unsigned DimLen; // Maximum length without reallocation
  209.   unsigned Len;    // Logical length of text
  210.   int GrowBy;      // Minimum resizing increment
  211.  
  212. public: // Class type to ostream type conversions
  213.   friend ostream &operator<<(ostream &os, const UString &s);
  214.   friend istream &operator>>(istream &os, UString &s);
  215.  
  216. public: // Overloaded operators
  217.   char &operator[](unsigned i) {
  218.     if(EnsureUnique()) // Ensure unique before allowing modifications
  219.       return TextPtr[CheckIndex(i)];
  220.     else return StrData::Null_Ptr.Data[0]; // Point byte to null string
  221.   }
  222.  
  223.   void operator+=(const UString &s) { Cat(s.TextPtr, s.Len); }
  224.   void operator+=(const char *s) { Cat(s, strlen(s)); }
  225.   void operator+=(const char c) { Cat(&c, 1); }
  226.   friend UString operator+(const UString &a, const UString &b)
  227.   {
  228.     UString buf(a.Len + b.Len);
  229.     buf += a;
  230.     buf += b;
  231.     return buf;
  232.   }
  233.  
  234.   friend int operator==(const UString &a, const UString &b)
  235.   {
  236.     return StringCompare(a, b) == 0;
  237.   }
  238.  
  239.   friend int operator!=(const UString &a, const UString &b)
  240.   {
  241.     return StringCompare(a, b) != 0;
  242.   }
  243.  
  244.   friend int operator>(const UString &a, const UString &b)
  245.   {
  246.     return StringCompare(a, b) > 0;
  247.   }
  248.  
  249.   friend int operator>=(const UString &a, const UString &b)
  250.   {
  251.     return StringCompare(a, b) >= 0;
  252.   }
  253.   
  254.   friend int operator<(const UString &a, const UString &b)
  255.   {
  256.     return StringCompare(a, b) < 0;
  257.   }
  258.   
  259.   friend int operator<=(const UString &a, const UString &b)
  260.   {
  261.     return StringCompare(a, b) <= 0;
  262.   }
  263.  
  264. public: // Friend functions
  265.   // Returns -1 if a < b, 0 if a == b, and 1 if a > b
  266.   friend int StringCompare(const UString &a, const UString &b);  
  267. };
  268.  
  269. // General-purpose string routines that need to be ported from UNIX to DOS
  270. int CaseICmp(const UString &s1, const UString &s2);
  271. int CaseICmp(UString &s1, UString &s2);
  272.  
  273. #endif  // __USTRING_HPP //
  274. // ----------------------------------------------------------- // 
  275. // ------------------------------- //
  276. // --------- End of File --------- //
  277. // ------------------------------- //
  278.  
  279.